 Bonjour à tous, bienvenue dans les cours de l'UE de principes des systèmes d'exploitation.
 Aujourd'hui, on va voir un mécanisme fondamental qui est utilisé par les systèmes d'exploitation,
 qui sont les interruptions.
 L'interruption, c'est un signal qui est généré par le matériel
 pour notifier un événement au système d'exploitation.
 Le point important ici, c'est que c'est vraiment le matériel qui déclenche l'interruption
 et c'est le système qui le traite en mode particulier du processeur,
 lorsqu'on a vu les modes d'exécution, qui est le mode système.
 Donc à chaque fois, vous avez toujours ces trois étapes.
 Le matériel génère une interruption, on va voir par quels mécanismes,
 quels sont les différents types d'interruption.
 Lorsque l'interruption est déclenchée, ça interrompt l'exécution en cours sur le processeur
 et le système d'exploitation reprend la main pour traiter l'interruption
 en mode privilégié du processeur, qu'on appelle le mode système, mode S.
 On peut classifier les interruptions selon deux grands types d'interruption.
 Les premiers types d'interruption sont les IRQ ou interruptions matérielles.
 Ce sont des interruptions qui sont générées par les contrôleurs externes et de façon asynchrone.
 C'est-à-dire qu'il y a une interruption qui est levée indépendamment de l'exécution du programme.
 Un programme s'exécute et tout d'un coup il est interrompu
 par une interruption qui est générée par les contrôleurs externes.
 Je vous rappelle à ce qu'on a vu la dernière fois que sur une machine vous avez le processeur central,
 qu'on appelle le CPU, autour duquel gravitent plusieurs processeurs spécialisés,
 qu'on appelle les contrôleurs, pour gérer le disque, le réseau, la console.
 Donc tout cet ensemble de contrôleurs peuvent à tout moment générer des interruptions
 qui sont asynchrones et qui vont interrompre le traitement en cours.
 Les exemples typiques d'interruptions qu'on va manipuler dans ce cours
 sont les interruptions liées aux fins de transfert.
 Lorsqu'un contrôleur disque a fini de faire son transfert en mémoire,
 il génère une interruption pour notifier au système d'exploitation que le transfert a terminé.
 De même, lorsqu'il y a une saisie au clavier ou à la cerise,
 cela va générer des interruptions pour qu'on puisse les traiter.
 Le troisième type d'interruption qu'on verra et qu'on détaillera plus dans le cours prochain,
 c'est l'interruption horloge.
 Cette interruption est notamment utilisée par les systèmes d'exploitation pour implémenter du temps partagé.
 Je reviendrai plus tard sur cette interruption horloge qui est importante.
 C'est le premier type d'interruption dans lequel les interruptions ne sont pas liées à l'exécution du process en cours.
 Le process en cours fonctionne tout à fait normalement et tout d'un coup les contrôleurs externes l'interrompent.
 Un autre type d'interruption, appelé l'interruption logicielle ou des exceptions,
 doit être générée de façon synchrone par les programmes en cours d'exécution.
 C'est le programme, par son exécution, qui va déclencher une interruption.
 L'exemple typique, c'est les erreurs.
 Si votre programme fait une erreur, par exemple, il est en train de s'exécuter sur le processeur central,
 il fait une division par zéro ou il fait une erreur d'adressage.
 Ce qui peut déjà arriver lorsque vous manipulez une mauvaise adresse de pointeur.
 Le processeur va détecter le problème et va générer une interruption.
 Un deuxième type d'interruption qui n'est pas lié aux erreurs, ce sont les appels système.
 Je vous avais dit la dernière fois que les programmes, lorsqu'ils s'exécutent, peuvent demander des services au système.
 Par exemple, pour obtenir l'heure, créer un processus, accéder à des fichiers.
 C'est ce qu'on appelle des appels système.
 À chaque fois que vous demandez aux services au système, il va falloir basculer en mode système pour pouvoir traiter cet appel système.
 Ce qu'on appelle aussi une interruption logicielle, c'est le programme lui-même qui, de façon synchrone, déclenche une interruption
 parce qu'il a besoin d'un service du système d'exploitation.
 Dans tous les cas, les interruptions logicielles sont liées à l'exécution du programme.
 Soit il fait des erreurs, soit il demande explicitement un service au système d'exploitation.
 On voit qu'il y a plusieurs sources d'interruptions.
 Quand un programme s'exécute, il peut y avoir des interruptions liées au contrôleur externe
 et des interruptions liées à l'exécution du programme.
 À un moment donné, je peux avoir plusieurs interruptions qui ont conduit de manière concurrente.
 Je peux avoir une interruption de 10, qui demande un appel système.
 Donc il faut, en cas d'interruption qui a conduit de manière concurrente,
 plusieurs interruptions en parallèle, définir dans quel ordre on va traiter ces interruptions.
 Il y a une notion de priorité des interruptions, qu'on retrouve dans les machines et dans les systèmes d'exploitation.
 Classiquement, dans la plupart des systèmes, on retrouve les priorités suivantes.
 Plus prioritaire, moins prioritaire. Plus le numéro est petit, plus vous êtes prioritaire.
 L'interruption plus prioritaire, c'est l'horloge.
 Dès qu'il y a une interruption déclenchée par le composant interne qu'on appelle l'horloge,
 qu'on verra plus tard, à ce moment-là, l'interruption sera traitée prioritairement.
 Ensuite, une interruption assez prioritaire, c'est l'interruption liée au disque.
 Par exemple, lorsque j'ai une fin de transfert et une fin d'entrée/sortie,
 cela déclenche une interruption, cette interruption est assez prioritaire.
 Par contre, elle est moins prioritaire que l'horloge.
 Si en même temps, j'ai l'horloge et le disque qui sont déclenchés,
 ça c'est déclenché par deux composants différents,
 il y en a un qui est déclenché par le composant horloge, l'autre qui est déclenché par le contrôleur disque,
 c'est possible qu'il y ait une interruption liée de manière quasi-simultanée,
 à ce moment-là, on traitera d'abord l'horloge, puis le disque, parce que l'horloge est plus prioritaire.
 Et ainsi de suite, on continue.
 Une interruption qui est moins prioritaire que le disque, c'est l'air-console.
 Tout ce qui est lié au clavier/souris, c'est moins prioritaire qu'une interruption de disque.
 Et ainsi de suite, il peut y avoir d'autres périphériques également.
 Et enfin, ce qui est le moins prioritaire parmi les ensembles des interruptions,
 ce sont les appels système.
 Lorsque le programme demande un appel système, c'est moins prioritaire qu'une interruption de disque,
 c'est moins prioritaire qu'une interruption horloge, c'est moins prioritaire qu'une interruption clavier.
 Donc ça, c'est défini, les ordres dans lesquels on va traiter les interruptions,
 lorsqu'il y en a plusieurs qui arrivent en même temps.
 Donc comment sont traitées les interruptions ?
 On a vu qu'il y a deux sources d'interruptions,
 soit les interruptions matérielles déclenchées de manière externe,
 soit les interruptions logicielles déclenchées par l'exécution des programmes.
 Donc ça, ça m'entraîne exactement le même mécanisme.
 L'interruption, que ce soit une IRQ matérielle ou une exception logicielle,
 ça va vous entraîner une trappe qui va vous basculer en mode système.
 Donc il y a vraiment un basculement du mode utilisateur au mode système.
 Dans le système d'exploitation, on va exécuter un code spécifique qui est lié à l'interruption.
 Donc à chaque interruption, il y a un numéro,
 et donc on va exécuter un code spécifique lié à l'interruption.
 Si une ferme d'entrée est sortie, ce n'est pas le même code que si c'est une division par zéro, et ainsi de suite.
 Ou un appel système.
 Donc à chaque fois, en fonction du numéro d'interruption,
 dans tous les cas on bascule en mode système,
 et il y aura un traitement qui est spécifique à l'interruption qui a été déclenchée.
 Et tout ça s'exécute en mode système.
 Donc ce sont des morceaux de code de votre noyau,
 des morceaux de code de Linux ou de Windows qui vont s'exécuter ici.
 Ce ne sont pas un morceau de code du programme.
 Pour des questions de sécurité, puisque ici on s'exécute en mode privilégié de processeur,
 donc on a accès à toutes les ressources.
 On peut modifier n'importe quel emplacement mémoire.
 Donc l'interruption est traitée.
 Une fois qu'elle est traitée, il y a un mécanisme inverse.
 On va rebasculer en mode utilisateur, et on va continuer à s'exécuter en mode utilisateur.
 Vous remarquez ici que ce n'est pas forcément le même programme qu'au départ.
 Lorsque j'ai une interruption, j'ai P1 qui a été interrompue,
 et la reprise se fait sur un process P2.
 Si ça se trouve, il y a un process plus prioritaire,
 et on préfère redonner la main à un process plus prioritaire.
 Ce n'est pas forcément le même processus qui va s'exécuter à la fin d'interruption.
 Si on zoome un peu sur ce schéma,
 imaginons qu'il y a une interruption X qui est déclenchée.
 Au début, la première étape, c'est l'étape numéro 1, basculement en mode système.
 Comment se passe le basculement en mode système ?
 Au niveau de chaque machine, il y a un registre particulier qu'on appelle le programme status_form,
 PSW, ou mode état du processeur,
 qui caractérise l'état courant d'exécution du processeur.
 Cela dépend des architectures. Dans toutes les architectures, vous avez un PSW.
 Dans ce registre, il y a l'état du processeur au moment où l'interruption a lieu.
 Est-ce que votre processeur était actif ou inactif ?
 Au moment où l'interruption a déclenché, votre Intel ne faisait rien.
 Votre CPU n'était en train de rien faire.
 Il y a l'état courant du processeur au moment de l'interruption.
 Dans quel mode s'exécutait la machine au moment où l'interruption a lieu ?
 Est-ce qu'elle était en mode utilisateur ou en mode système ?
 Il y a aussi les interruptions qui sont masquées au moment où l'interruption a déclenché.
 On va en revenir dessus juste après.
 Enfin, vous avez, si vous étiez actif, à quel endroit du code vous étiez positionné.
 Dans le processus source, on retrouve ces quatre éléments.
 L'état du processeur, le mode d'exécution, le masque d'interruption,
 et l'endroit où vous vous situez dans le code d'exécution.
 Le point de compteur, je vous le rappelle, on utilisera la chronique PC ou CO en français,
 qui indique la prochaine instruction à exécuter.
 C'est ce qui s'appelle le RIP dans la terminologie Intel.
 Le pointeur d'instruction, le registre, pointeur d'instruction.
 Vous avez ce PSW qui caractérise l'état courant du processeur.
 Lorsqu'il y a une interruption, il va y avoir ce qu'on appelle un basculement du mode état.
 On va sauvegarder le mode état courant.
 Là, j'exécute un mode utilisateur à tel endroit de mon code.
 Ce PSW va être sauvegardé.
 On va charger un nouveau mode état pour dire
 "Maintenant, j'exécute le moyeu, je change ces bits-là du mode état,
 et je change le point de compteur pour exécuter non pas un morceau de code du processus P1,
 mais un morceau de code du moyeu."
 Ça, c'est fait automatiquement par le matériel.
 Dès que j'ai une interruption, il y a un basculement du mode état
 pour vous faire exécuter un morceau de code du moyeu.
 Le mode état est modifié automatiquement par le matériel.
 Donc il y a ce basculement du mode état.
 Avant d'exécuter la routine de traitement d'interruption,
 on va sauvegarder les registres du processus courant.
 En plus du mode état, on va sauvegarder un certain nombre de registres
 pour pouvoir restituer le contexte de P1
 lorsque l'interruption sera terminée.
 Ensuite, on a fait les étapes 1 et 2,
 donc on a basculé en mode système.
 Il faut déterminer quelle est la fonction à exécuter dans le système d'exploitation.
 Pour déterminer la fonction à exécuter,
 pour chaque interruption,
 que ce soit un entrée/sortie, l'horloge, une division par 0, etc.,
 il faut exécuter une fonction spécifique.
 L'ensemble des fonctions à exécuter sont regroupées dans un vecteur d'interruption
 qui indique pour chaque interruption, pour chaque numéro d'interruption,
 quelle est l'adresse de la fonction qui doit s'exécuter.
 C'est ce qu'on appelle un vecteur d'interruption.
 Le vecteur d'interruption ne peut être modifié qu'en mode système.
 Le programme utilisateur P1 n'a pas le droit d'aller modifier ce vecteur d'interruption.
 Ce vecteur a une entrée pour chaque type d'interruption,
 que ce soit une interruption de logiciel ou de l'intérieur.
 Par exemple, sur les Intel, le vecteur d'interruption a 255 entrées.
 Cela s'appelle l'IDT, pour Interrupt Descriptor Table.
 C'est un tableau de fonctions, de pointeurs de fonctions.
 Pour l'interruption X, cela vous indique directement l'adresse de la fonction à exécuter.
 Une fois qu'on a changé du mode état, on va faire un saut pour exécuter cette fonction.
 On exécute la routine IDT X.
 Cela désigne directement une fonction.
 Ce vecteur d'interruption est positionné par le système d'exploitation.
 C'est une des premières choses que font les systèmes d'exploitation lorsqu'on fait l'opération du boot.
 Par défaut, le vecteur d'interruption désigne des fonctions qui sont dans le BIOS.
 L'une des premières choses que font Linux ou Windows, au moment du démarrage,
 c'est de redéfinir les entrées du vecteur d'interruption pour désigner des fonctions internes à Linux ou à Windows.
 Si j'ai un appel système, il faut exécuter telle fonction.
 Si j'ai une horloge, c'est telle fonction qu'il doit s'exécuter.
 Le système d'exploitation, au démarrage, définit les entrées du vecteur d'interruption
 pour désigner des morceaux de code à lui, des morceaux de code internes au système d'exploitation.
 Ici, on a basculé en mode système grâce à la commutation du mode état.
 Grâce au vecteur d'interruption, je sais quelle est la fonction à exécuter dans le noyau.
 J'exécute cette fonction, donc je traite l'interruption et la traite.
 Et à la fin du traitement d'interruption, il va falloir faire l'opération inverse et rebasculer en mode utilisateur.
 Il y a deux étapes. Il va falloir déterminer le process à reprendre.
 Est-ce que je reprends mes vécutions sur le même processus qui a été interrompu, P1 ?
 Ou est-ce que je reprends sur un processus P2 ?
 On verra, il y aura ce qu'on appelle l'élection.
 Éventuellement, P1 a été interrompue et on va restituer les contextes de P2,
 parce que P2 est plus prioritaire.
 À la fin du traitement d'interruption, on détermine le processus à reprendre.
 Éventuellement, c'est le même processus.
 Si c'est un simple appel système, comme j'ai fait l'appel système getPID pour avoir mon numéro de PID,
 il y a de bonnes chances que le processus à reprendre soit moi-même.
 Donc il est possible que le processus à reprendre soit le processus qui a déclenché l'interruption.
 Mais il y a certains cas, par exemple un cas d'interruption horloge,
 si il y a une fin de comptable, le processus à reprendre n'est pas le même.
 À ce moment-là, on va choisir un nouveau processus P2 pour reprendre.
 Donc on détermine, une fois qu'on a traité la routine de traitement d'interruption,
 à la fin de la routine de traitement d'interruption, on détermine le processus à reprendre
 et on va restaurer les registres de ce processus.
 Et enfin, on fait le retour d'interruption qui fait la bascule inverse.
 C'est un basculement du mode état, mais dans l'autre sens, pour passer du mode système au mode utilisateur.
 Donc si je refais, on redit la même chose mais sur un autre schéma.
 Donc ici, imaginons que j'ai deux processus et deux systèmes d'exploitation.
 Donc j'ai deux processus P et Q. Une interruption a lieu,
 commutation du mode état, je bascule au mode système,
 je sauvegarde des registres additionnels de P, par exemple, l'emplacement lié dans sa pile, etc.
 Donc il y a un certain nombre de registres qu'il faut que je sauvegarde.
 Ensuite, grâce au vecteur d'interruption, je fais le traitement lié au spécifique à interruption qui avait déclenché.
 Ce qu'on a vu ici, quand je traite l'interruption,
 une fois qu'à la fin du traitement de l'interruption, je détermine le process à reprendre,
 imaginons que ce soit un autre process Q ici,
 et je restaure sur "registre" et à la fin je fais le retour d'interruption, ce qu'on appelle l'acquittement de l'interruption,
 et mon exécution continue, et donc là je suis de nouveau en mode utilisateur.
 Donc ici, P et Q sont en mode U, et le système d'exploitation s'exécute toujours en mode système.
 Donc on a basculé, on a changé de mode.
 Donc là, je vous ai dit tout à l'heure qu'il peut y avoir plusieurs interruptions, il y en a beaucoup,
 qui ont lieu lorsqu'un programme s'exécute.
 Donc un programme, il est souvent interrompu par les contrôleurs d'entrée/sortie,
 pour les transferts, à chaque transfert il est interrompu par l'horloge, il est interrompu par les claviers, etc.
 Donc il y a beaucoup d'interruptions qui ont lieu de manière concurrente.
 Donc là, ici, lorsqu'il y a plusieurs interruptions en cours,
 alors que je suis en train de traiter une interruption, une autre interruption arrive.
 Qu'est-ce qui se passe dans ce cas-là ?
 Si je suis par exemple en train de traiter une interruption disque,
 une nouvelle interruption horloge arrive, ce qui est possible.
 Lorsque je suis en train de traiter une interruption, même si je suis en mode système,
 une autre interruption peut arriver.
 Lorsqu'on est en mode système, toutes les interruptions ne sont pas masquées.
 Même lorsque je m'exécute dans le système d'exploitation, je peux avoir des interruptions.
 Quand le contrôleur disque ne sait pas qu'on est en train de s'exécuter en mode système.
 Donc lui, il génère une interruption dès que son transfert est terminé, par exemple.
 Donc lorsque je suis en train de traiter une interruption, une nouvelle interruption a lieu.
 Donc là, si la priorité de la nouvelle interruption est supérieure à la priorité de l'interruption qui est en cours d'exécution, dans le noyau,
 à ce moment-là, il faut d'abord traiter cette interruption avant de finir le traitement en cours.
 Il va falloir sauvegarder le contexte de l'interruption qui est en cours d'exécution dans une zone qu'on appelle la pile d'interruption.
 C'est une zone mémoire qui se trouve dans l'espace du système d'exploitation,
 qui est une pile dans laquelle on empile tous les traitements d'interruption.
 C'est ce qu'on appelle la pile d'interruption.
 On sauvegarde le contexte de l'interruption qu'on était en train de traiter sur la pile d'interruption.
 Je traite la nouvelle interruption. Une fois que le traitement de la nouvelle interruption est terminé,
 à ce moment-là, je restaure le contexte de mon ancienne interruption en dépilant ma sauvegarde.
 Ce qui est important, c'est qu'il y a une pile d'interruption, qu'on appelle soit pile d'interruption ou pile système,
 qui est utilisée dès que vous êtes en mode système.
 Dès que vous basculez en mode système, on ne s'exécute pas sur la pile du processus,
 mais on bascule sur la pile du système d'exploitation, qu'on appelle l'appel système.
 Pour résumer, imaginons que j'ai une première interruption de priorité très basse.
 Par exemple, mon programme utilisateur fait un appel système.
 Un appel système, je vous l'ai dit, c'est une interruption, qu'on appelle interruption logicielle.
 L'interruption est déclenchée directement par le programme.
 Le programme appelle une instruction interne du processeur, une trappe, qui vous fait basculer en mode système.
 Là, vous êtes en train de traiter l'appel système.
 À ce moment-là, le contrôleur disque génère une interruption pour dire qu'un transfert est terminé.
 J'ai une deuxième interruption qui arrive.
 À ce moment-là, on va sauvegarder le contexte sur ma pile système ou pile d'interruption.
 Je sauvegarde le contexte courant de mon interruption.
 Le sauvegarde, ça veut dire empiler le programme compteur pour dire que j'ai à tel endroit, à telle instruction dans le traitement de l'interruption 1.
 Je sauvegarde cette information au sommet de ma pile système.
 Puis, j'exécute la routine de traitement de l'interruption 2.
 L'interruption numéro 2, l'interruption disque, est traitée, et ainsi de suite.
 Pendant l'interruption disque, il est très possible d'avoir une interruption horloge.
 Pourquoi ? Parce que l'horloge est plus prioritaire que le disque.
 À ce moment-là, il faut interrompre le traitement de l'interruption disque.
 Pour ne pas perdre ce qu'on est en train de faire, on empile de nouveau la sauvegarde de l'interruption disque au sommet de la pile.
 Là, ici, j'ai deux sauvegardes.
 J'ai ma sauvegarde de l'appel système, ma sauvegarde de l'interruption disque, et j'exécute le traitement de l'interruption horloge.
 Ce qu'il faut savoir, c'est que souvent on a une idée fausse.
 On pense que lorsqu'on est dans le système d'exploitation, il ne peut pas y avoir d'interruption.
 Mais ce n'est pas vrai. Même quand je suis en train d'exécuter un traitement dans Linux ou dans Windows,
 je peux être interrompu. Ce n'est pas gênant.
 Parce que j'empile à chaque fois que je sauvegarde mon contexte courant au sommet de ma pile système.
 Donc, je traite mon interruption ici.
 A la fin du traitement d'interruption, je vais dépiler ma sauvegarde ici et restituer le contexte pour pouvoir finir le traitement de l'interruption disque.
 Une fois que le traitement de l'interruption disque, je dépile ma sauvegarde de l'interruption 1, qui est l'appel système, et je finis mon appel système.
 Donc, je peux très bien voir des scénarios comme celui-ci.
 Ensuite, il y a un mécanisme qui est important dans le système.
 Je vous ai dit que lorsque je m'exécute dans le mode système, je peux être interrompu.
 Pas d'interruption.
 Mais il y a des moments où le système d'exploitation n'a pas envie d'être interrompu.
 Il veut se protéger d'interruption.
 Donc, typiquement, lorsque vous êtes en train de traiter une fin de transfert depuis le disque,
 vous ne voulez pas qu'il y ait une autre interruption disque qui arrive pendant ce temps-là.
 C'est l'exemple typique.
 Il y a des mécanismes qui permettent au système de ne pas traiter une interruption tout de suite.
 Il y a deux grands mécanismes.
 Le premier mécanisme, qui est assez peu utilisé, et qui est utilisé uniquement en cas de problème,
 c'est ce qu'on appelle le désarmement d'interruption.
 Lorsque vous désarmez une interruption, c'est un mécanisme beaucoup plus dur,
 vous allez carrément annuler le traitement d'interruption.
 C'est-à-dire que si l'interruption a lieu, vous ne la traiteriez pas.
 On le fait très peu, on le fait en cas, par exemple, uniquement si vous avez un périphérique défaillant.
 Par exemple, vous avez un contrôleur qui est défaillant et qui vous bombarde d'interruption.
 Vous risquez de surcharger complètement le système d'exploitation pour traiter ces interruptions.
 Si le système détecte un périphérique défaillant, il va annuler le traitement de ces interruptions
 en désarmant les interruptions correspondantes.
 Donc en cas de panne d'un contrôleur, par exemple, on va annuler le traitement de ces interruptions
 pour éviter de trop perturber le système.
 Donc c'est un mécanisme qui est assez puis utilisé en cas de problème.
 Sinon, un autre mécanisme qui lui, par contre, est beaucoup plus utilisé,
 c'est ce qu'on appelle le masquage d'interruption.
 Donc lorsque vous masquez une interruption, on ne va pas annuler le traitement d'interruption,
 mais on va juste le retarder.
 Donc là, ici, pendant un certain temps, par exemple, si vous masquez une interruption de disque,
 même si une interruption de disque arrive,
 on mémorisera que l'interruption de disque a eu lieu,
 mais on ne la traitera que lorsqu'on démasquera l'interruption.
 Donc il y a un mécanisme de masque et de démasque.
 Donc à chaque fois, comment ça se présente dans les systèmes,
 il y a souvent une primitive interne des systèmes d'exploitation,
 dans laquelle vous pouvez masquer,
 vous faites masque l'équivalent d'une fonction interne qui s'appelle "masque",
 dans les unités qui s'appellent les SPL, souvent,
 dans lesquelles vous placez le numéro de l'interruption,
 donc à ce moment-là, quand vous faites "masque x",
 ça va masquer toutes les interruptions qui sont de priorité inférieure ou égale à x.
 Par exemple, si vous masquez l'horloge, vous masquez toutes les interruptions,
 parce que la priorité la plus forte dans les interruptions, c'est l'horloge.
 Par contre, si vous masquez le disque,
 vous masquez toutes les interruptions qui sont de priorité inférieure ou égale au disque,
 c'est-à-dire le disque lui-même, le clavier, etc.
 Qu'est-ce qui se passe ici par exemple ?
 Imaginons qu'il y ait une interruption horloge,
 je referai mon petit schéma tout à l'heure,
 je suis en train de traiter l'interruption horloge,
 par défaut, lorsque vous traitez une interruption,
 toutes les interruptions de priorité inférieure ou égale à l'interruption en cours sont masquées.
 Donc si j'ai une interruption horloge,
 toutes les interruptions de disque, console, etc. sont masquées.
 Pendant le traitement de l'interruption horloge,
 si j'ai une interruption de disque ici,
 je ne vais pas l'empiler sur ma pile système,
 comme on l'a vu tout à l'heure,
 parce que le disque est moins prioritaire que l'horloge.
 Par défaut, lors du traitement de l'horloge,
 toutes les interruptions de disque sont masquées.
 Elle ne sera traitée que lorsqu'on aura fini le traitement de l'interruption de disque,
 à ce moment-là, le disque n'est plus masqué.
 On pourra le traiter.
 Donc le masquage consiste simplement à retarder le traitement d'une interruption.
 [SILENCE]
